/*
 * 原版接口
 */
import * as server_ui from "@minecraft/server-ui";
import * as server from "@minecraft/server";
/*
 * 蛋白石数据
 */
import * as data_entity from "../data/entity";
/*
 * 蛋白石组件
 */
import * as power_property from "../system/power_property";
import * as derived_tools from "../system/derived_tools";
import * as native_tools from "../system/native_tools";
import * as achieve_plan from "../system/achieve_plan";
import * as query_intel from "../system/query_intel";
import * as math_tools from "../system/math_tools";
/**
 * * 锚点虚印
 */
export function DynamicAnchorPointTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 标题
             */
            const title: server.RawMessage = {
                text: "§r<§9§o§l 锚点虚印 §r>§9操作界面"
            };
            /**
             * * 选项
             */
            const option: server.RawMessage[] = [
                { text: '<§5§o§l 锚点绑定 §r>' },
                { text: '<§9§o§l 锚点召集 §r>' },
                { text: '<§4§o§l 锚点移除 §r>' },
                { text: '<§9§o§l 锚点传送 §r>' }
            ];
            /**
             * * 获取 窗口对象
             */
            const display = new server_ui.ActionFormData()
                .title(title)
                .button(option[0], "textures/物品贴图/特殊道具/锚点虚印")
                .button(option[1], "textures/物品贴图/特殊道具/锚点虚印")
                .button(option[2], "textures/物品贴图/特殊道具/锚点虚印")
                .button(option[3], "textures/物品贴图/特殊道具/锚点虚印")
            // 显示 操作界面
            display.show(player).then(
                result => {
                    if (result.canceled) return;
                    // 根据 选项 进行 不同 处理
                    switch (result.selection) {
                        // 绑定模式
                        case 0: BindingAnchor(player); break;
                        // 召集模式
                        case 1: MusterAnchor(player); break;
                        // 移除模式
                        case 2: DeleteAnchor(player); break;
                        // 传送模式
                        case 3: ArrivalAnchor(player); break;
                    }
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 锚点绑定
 */
function BindingAnchor(player: server.Player) {
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
        excludeFamilies: ["monster", "player"]
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 实体数组
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => !entity.getDynamicProperty('entity:false_anchor_point'));
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9§l<§u 锚点绑定 §9>§r§3操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    // 遍历 实体数组 并 加入 按钮
    queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/特殊道具/锚点虚印"));
    if (queue.length < 1) display.button('§4§l周围不存在 §c<§9 可以§6<§u 锚点绑定 §6>§9的实体 §c>§r', "textures/物品贴图/特殊道具/锚点虚印");
    // 播放 音效
    player.playSound('item.book.page_turn');
    // 显示 窗口界面
    display.show(player).then(
        option => {
            if (option.selection == undefined || queue.length === 0) return;
            /**
             * * 获取 目标 实体
             */
            const target = queue[option.selection];
            // 设定 锚点绑定
            target.setDynamicProperty('entity:false_anchor_point', player.id);
            player.sendMessage([{ text: '正在执行§9§l<§u 锚点绑定 §9>§r: ' }, native_tools.EntityTranslate(target)]);
        }
    )
};
/**
 * * 锚点召集
 */
function MusterAnchor(player: server.Player) {
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
        excludeFamilies: ["monster", "player"]
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 实体数组
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => entity.getDynamicProperty('entity:false_anchor_point') == player.id);
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9§l<§u 锚点召集 §9>§r§3操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title).button('§l< 召集全部 >', "textures/物品贴图/特殊道具/锚点虚印");
    // 遍历 实体数组 并 加入 按钮
    queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/特殊道具/锚点虚印"));
    if (queue.length < 1) display.button('§4§l周围不存在 §c<§9 完成§6<§u 锚点召集 §6>§9的实体 §c>§r', "textures/物品贴图/特殊道具/锚点虚印");
    // 显示 窗口界面
    display.show(player).then(
        option => {
            // 检测 是否满足 运行条件
            if (option.selection == undefined || queue.length === 0) return;
            // 运行 锚点召集
            if (option.selection == 0) {
                queue.forEach(entity => entity.teleport(player.location));
                player.sendMessage({ text: '正在执行§9§l<§u 锚点召集 §9>§r' });
            }
            else {
                /**
                 * * 获取 目标 实体
                 */
                const target = queue[option.selection - 1];
                // 设定 锚点召集
                target.teleport(player.location);
                player.sendMessage([{ text: '正在执行§9§l<§u 锚点召集 §9>§r: ' }, native_tools.EntityTranslate(target)]);
            }
        }
    )
};
/**
 * * 锚点移除
 */
function DeleteAnchor(player: server.Player) {
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
        excludeFamilies: ["monster", "player"]
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 实体数组
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => entity.getDynamicProperty('entity:false_anchor_point') == player.id);
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9§l<§u 锚点移除 §9>§r§3操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    // 遍历 实体数组 并 加入 按钮
    queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/特殊道具/锚点虚印"));
    if (queue.length < 1) display.button('§4§l周围不存在 §c<§9 可以§6<§u 锚点移除 §6>§9的实体 §c>§r', "textures/物品贴图/特殊道具/锚点虚印");
    // 显示 窗口界面
    display.show(player).then(
        option => {
            // 检测 是否满足 运行条件
            if (option.selection == undefined || queue.length === 0) return;
            /**
             * * 获取 目标 实体
             */
            const target = queue[option.selection];
            // 设定 锚点移除
            target.setDynamicProperty('entity:false_anchor_point');
            player.sendMessage([{ text: '正在执行§9§l<§u 锚点移除 §9>§r: ' }, native_tools.EntityTranslate(target)]);
        }
    )
};
/**
 * * 锚点传送
 */
function ArrivalAnchor(player: server.Player) {
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
        excludeFamilies: ["monster", "player"]
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 实体数组
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => entity.getDynamicProperty('entity:false_anchor_point') == player.id);
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9§l<§u 锚点召集 §9>§r§3操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title).button('§l< 随机传送 >', "textures/物品贴图/特殊道具/锚点虚印");
    // 遍历 实体数组 并 加入 按钮
    queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/特殊道具/锚点虚印"));
    if (queue.length < 1) display.button('§4§l周围不存在 §c<§9 完成§6<§u 锚点召集 §6>§9的实体 §c>§r', "textures/物品贴图/特殊道具/锚点虚印");
    // 显示 窗口界面
    display.show(player).then(
        option => {
            // 检测 是否满足 运行条件
            if (option.selection == undefined || queue.length === 0) return;
            // 运行 锚点召集
            if (option.selection == 0) {
                /**
                 * * 获取 目标 实体
                 */
                const target = queue[math_tools.Random({ min: 1, max: queue.length - 1 }, true)];
                // 设定 锚点传送
                player.teleport(target.location);
                player.sendMessage([{ text: '正在执行§9§l<§u 锚点传送 §9>§r: ' }, native_tools.EntityTranslate(target)]);
            }
            else {
                /**
                 * * 获取 目标 实体
                 */
                const target = queue[option.selection - 1];
                // 设定 锚点传送
                player.teleport(target.location);
                player.sendMessage([{ text: '正在执行§9§l<§u 锚点传送 §9>§r: ' }, native_tools.EntityTranslate(target)]);
            }
        }
    )
};
/**
 * * 神机操持
 */
export function MechanizedOperationTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 过滤器参数
             */
            const queryOptions: server.EntityQueryOptions = {
                type: 'entity_machine:whale_support',
                location: player.location,
                maxDistance: 5
            };
            /**
             * * 获取 附近的 渊鲸
             */
            const whale = player.dimension.getEntities(queryOptions);
            /**
             * * 界面标题
             */
            const title: server.RawMessage = {
                text: "§r<§9§o§l 神机操持 §r>§9操作界面"
            };
            /**
             * * 界面选项
             */
            const option: server.RawMessage[] = [
                { text: '<§5§o§l 上浮模式 §r>' },
                { text: '<§5§o§l 下潜模式 §r>' },
                { text: '<§9§o§l 列车行进 §r>' },
                { text: '<§9§o§l 列车左旋 §r>' },
                { text: '<§9§o§l 列车右旋 §r>' },
            ];
            const trainOptions: server.EntityQueryOptions = {
                families: ['train'],
                maxDistance: 48,
                location: player.location
            };
            // 播放 音效
            player.playSound('respawn_anchor.charge');
            // 显示 界面
            new server_ui
                .ActionFormData()
                .title(title)
                .button(option[0], "textures/项目图标/神机操持/上浮模式")
                .button(option[1], "textures/项目图标/神机操持/下潜模式")
                .button(option[2], "textures/项目图标/神机操持/载具行驶")
                .button(option[3], "textures/项目图标/神机操持/左舷回转")
                .button(option[4], "textures/项目图标/神机操持/右舷回转")
                .show(player).then(
                    select => {
                        //对 用户选项 做出反应
                        switch (select.selection) {
                            //启动 上浮模式
                            case 0:
                                //检测实体是否满足环境测试
                                whale.forEach(
                                    entity => {
                                        /**
                                         * * 获取 玩家下方的 方块
                                         */
                                        const block = entity.dimension.getBlock(entity.location);
                                        //如果玩家下方有水 就 解除渊鲸 的 航行限制
                                        if (block?.typeId == "minecraft:water") entity.triggerEvent('entity_event:secure_prohibit');
                                    }
                                );
                                whale.forEach(info => info.triggerEvent('entity_event:immediately_float'));
                                break;

                            //启动 下潜模式
                            case 1:
                                whale.forEach(info => info.triggerEvent('entity_event:immediately_dive'))
                                break;

                            // 启动 列车行进
                            case 2:
                                native_tools.GetContractRoles(player, trainOptions, (entity) => entity.triggerEvent('entity_event:switch'));
                                player.playSound('tile.piston.out');
                                break;

                            // 启动 列车左旋
                            case 3:
                                native_tools.GetContractRoles(player, trainOptions, (entity) => entity.addTag('tunnel_train.Sinistral'));
                                player.playSound('tile.piston.out');
                                break;

                            // 启动 列车右旋
                            case 4:
                                native_tools.GetContractRoles(player, trainOptions, (entity) => entity.addTag('tunnel_train.Dextral'));
                                player.playSound('tile.piston.out');
                                break;
                        }
                    }
                );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 参悟之石
 */
export function EnlightenentTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 设置 实体 的 查询条件
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb", player.typeId],
                excludeFamilies: ["monster"]
            };
            /**
             * * 获取 实体 的 距离信息
             */
            const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
            /**
             * * 实体过滤器
             */
            const Filter = (entity: server.Entity) => {
                if (!entity.getComponent('minecraft:health')) return false;
                return true;
            };
            /**
             * * 获取 实体组 并 过滤掉 无法驯服的实体
             */
            const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), Filter);
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "§9§l<§u 参悟之石 §9>§r§3操作界面"
            };
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData().title(title);
            // 在实体队列中添加当前玩家
            queue.unshift(player);
            // 遍历 实体数组 并 加入 按钮
            queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/特殊道具/参悟之石"));
            // 播放 音效
            player.playSound('bucket.empty_lava');
            // 显示 窗口界面
            display.show(player).then(
                option => {
                    if (option.selection == undefined || queue.length == 0) return;
                    /**
                     * * 获取 目标 实体
                     */
                    const target = queue[option.selection];
                    /**
                     * * 实体属性
                     */
                    const property = power_property.GetProperty(target);
                    /**
                     * * 实体血量
                     */
                    const health = target.getComponent('health');
                    /**
                     * * 获取 战斗经验值
                     */
                    const experience = target.getDynamicProperty('entity:experience') as number ?? 0;
                    /**
                     * * 用户ID
                     */
                    const userId = target.getDynamicProperty('entity:contract_user') as string;
                    /**
                     * * 用户名称
                     */
                    const userName = userId ? server.world.getEntity(userId)?.nameTag : '未知';
                    /**
                     * * 限制数值的范围
                     * 
                     * @param {number} value - 数值
                     * 
                     * @returns {number} 限定范围内的数值
                     */
                    const Clamp = (value: number): number => math_tools.Clamp({ max: data_entity.max_experience, min: 0 }, value);
                    /** 
                     * * 界面标题 
                     */
                    const title: server.RawMessage = {
                        rawtext: [
                            { text: '§u『§l ' }, native_tools.EntityTranslate(target), { text: ' §u』' }
                        ]
                    };
                    /**
                     * * 界面内容
                     */
                    const body: server.RawMessage = {
                        rawtext: [
                            { text: `[§q§l 实体血量 §r] : §l§2${Math.floor((health?.currentValue ?? 0))}§r /§l§3 ${health?.defaultValue ?? 0}§r\n` },
                            { text: `[§p§l 实体归属 §r] : §l§6${userName}§r\n` },
                            { text: `[§1§l 战术等级 §r] : §l§9${Clamp(Math.floor(experience / data_entity.experience_improve))}§r\n` },
                            { text: `[§s§l 战斗经验 §r] : §l§b${experience}§r\n` },
                        ]
                    };
                    /** 
                     * * 表单对象
                     */
                    const display = new server_ui.ActionFormData()
                        .title(title)
                        .body(body)
                        .button(`提升§l§1[§9 基础攻击 §1]§r : §l§2${property.basic_attack}§r /§l§3 100 §r<§u§l +5 §r>`)
                        .button(`提升§l§1[§9 基础暴击 §1]§r : §l§2${property.erupt_odds}%% §r /§l§3 100%% §r<§u§l +5%% §r>`)
                        .button(`提升§l§1[§9 基础暴伤 §1]§r : §l§2${property.erupt_hurt}%% §r /§l§3 500%% §r<§u§l +25%% §r>`)
                        .button(`§l§1[§9 技能模组 §1]§r`)
                    // 判断 目标实体 与 手持物品 是否存在
                    if (!item || !target) return;
                    // 显示 窗口界面
                    display.show(player).then(
                        option => {
                            switch (option.selection) {
                                case 0:
                                    if (property.basic_attack > 95) return player.sendMessage(`§l§4<§c 基础攻击 §4>§r已到达上限, 无法继续提升`);
                                    player.sendMessage(`§l§1<§9 基础攻击 §1>§t获得提升, 现在为§r: §l§u${property.basic_attack + 5}`);
                                    power_property.AlterProperty(target, { basic_attack: 5 });
                                    // 减少 物品堆栈
                                    if (item.amount > 1) {
                                        item.amount -= 1;
                                        container.setItem(player.selectedSlotIndex, item);
                                    }
                                    else container.setItem(player.selectedSlotIndex);
                                    break;

                                case 1:
                                    if (property.erupt_odds > 95) return player.sendMessage(`§l§4<§c 基础暴击 §4>§r已到达上限, 无法继续提升`);
                                    player.sendMessage(`§l§1<§9 基础暴击 §1>§t获得提升, 现在为§r: §l§u${property.erupt_odds + 5}%`);
                                    power_property.AlterProperty(target, { erupt_odds: 5 });
                                    // 减少 物品堆栈
                                    if (item.amount > 1) {
                                        item.amount -= 1;
                                        container.setItem(player.selectedSlotIndex, item);
                                    }
                                    else container.setItem(player.selectedSlotIndex);
                                    break;

                                case 2:
                                    if (property.erupt_hurt > 475) return player.sendMessage(`§l§4<§c 基础暴伤 §4>§r已到达上限, 无法继续提升`);
                                    player.sendMessage(`§l§1<§9 基础暴伤 §1>§t获得提升, 现在为§r: §l§u${property.erupt_hurt + 25}%`);
                                    power_property.AlterProperty(target, { erupt_hurt: 25 });
                                    // 减少 物品堆栈
                                    if (item.amount > 1) {
                                        item.amount -= 1;
                                        container.setItem(player.selectedSlotIndex, item);
                                    }
                                    else container.setItem(player.selectedSlotIndex);
                                    break;

                                case 3: query_intel.GameHelp(player, target);; break;

                                default: break;
                            }
                        }
                    )
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 涤尽铅华
 */
export function ReductionPurenessTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 设置 实体 的 查询条件
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb", player.typeId],
                excludeFamilies: ["monster"]
            };
            /**
             * * 获取 实体 的 距离信息
             */
            const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
            /**
             * * 实体过滤器
             */
            const Filter = (entity: server.Entity) => {
                if (!entity.getComponent('minecraft:health')) return false;
                if (entity.getDynamicProperty('entity:contract_user') !== player.id) return false;
                return true;
            };
            /**
             * * 获取 实体组 并 过滤掉并未签订契约的实体
             */
            const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => Filter(entity));
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "§9§l<§u 涤尽铅华 §9>§r§3操作界面"
            };
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData().title(title);
            // 遍历 实体数组 并 加入 按钮
            if (queue.length >= 1) queue.forEach(entity => display.button(native_tools.DistanceAndName(entity, Distance(entity)), "textures/物品贴图/召唤凭证/星月诗篇"));
            else display.button('§4§l周围不存在 §c<§9 可以§6<§2 纯净化 §6>§9的实体 §c>§r', "textures/物品贴图/召唤凭证/星月诗篇");
            // 播放 音效
            player.playSound('bucket.empty_lava');
            // 显示 窗口界面
            display.show(player).then(
                option => {
                    if (option.selection == undefined || queue.length == 0) return;
                    /**
                     * * 获取 目标 实体
                     */
                    const target = queue[option.selection];
                    /**
                     * * 定义 相机参数
                     */
                    const camera = player.camera;
                    /**
                     * * 粒子参数
                     */
                    const molang = new server.MolangVariableMap();
                    /**
                     * * 复制实体坐标
                     */
                    const anchor_0 = math_tools.Vector.copy(target.location);
                    /**
                     * * 复制实体坐标
                     */
                    const anchor_1 = math_tools.Vector.add(anchor_0, { x: 0, y: 2, z: 0 });
                    /**
                     * * 创建 百灵绘卷 物品对象
                     */
                    const material = new server.ItemStack('item_voucher:moon_and_stars');
                    /**
                     * * 物品名称
                     */
                    const name = '§b启航星语 - §s';
                    /**
                     * * 物品词缀
                     */
                    const lore = [
                        `类型: ${target.typeId}`,
                        `名称: ${target.nameTag}`,
                        `坐标: ${math_tools.Vector.toString(player.location)}`,
                        `维度: ${player.dimension.id}`,
                        "§u___________________",
                        "使用时, 请在心中默念:",
                        "隐藏着< 元素力量 >的符纸啊",
                        "在我面前显示你真正的力量!",
                        `我以 ${player.nameTag} 之名命令你`,
                        "—— 封印解除! ૮₍ ᵕoᵕ₎ა"
                    ];
                    // 封印实体
                    derived_tools.UnloadInventoryAndPackage(target, player, material, name, lore);
                    // 设置 粒子尺寸
                    molang.setFloat('variable.size', 4);
                    // 播放 蝴蝶特效
                    molang.setFloat('variable.direction', 3);
                    native_tools.TrySpawnParticle(player.dimension, 'scripts:path_butterfly', anchor_0, molang);
                    // 播放 圆环特效
                    molang.setFloat('variable.direction', 0);
                    native_tools.TrySpawnParticle(player.dimension, 'scripts:path_round', anchor_1, molang);
                    // 播放 四芒星特效
                    native_tools.TrySpawnParticle(player.dimension, 'scripts:path_diamond', anchor_1, molang);
                    // 播放 封印动画
                    camera.setCamera('minecraft:free', { location: math_tools.Vector.add(anchor_0, { x: 5, y: 5, z: 5 }), facingLocation: anchor_0, easeOptions: { easeTime: 2 } });
                    server.system.runTimeout(() => camera.fade({ fadeColor: { red: 0, green: 0, blue: 0 }, fadeTime: { fadeInTime: 1, fadeOutTime: 0.5, holdTime: 0.5 } }), 30);
                    server.system.runTimeout(() => player.playSound('mob.allay.idle'), 60);
                    server.system.runTimeout(() => player.teleport(anchor_0), 60);
                    server.system.runTimeout(() => camera.clear(), 60);
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 涵养灵露
 */
export function MomentRepairDewTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            // 播放 基础使用音效
            player.playSound('fire.ignite');
            // 遍历 玩家背包
            for (let index = 0; index < container.size; index++) {
                /**
                 * * 获取 背包中的物品对象
                 */
                const getItem = container.getItem(index);
                /**
                 * * 获取 物品耐久度
                 */
                const durability = getItem?.getComponent('durability');
                // 跳过 无效物品
                if (!getItem || !durability || durability.damage == 0) continue;
                // 显示 文本提示
                player.sendMessage([native_tools.ItemTranslate(getItem), ' §a§l修复成功!']);
                // 删除 物品
                native_tools.DeleteItemStack(container, new server.ItemStack(item.typeId));
                // 恢复 物品耐久度
                durability.damage -= durability.damage;
                // 播放 恢复音效
                player.playSound('conduit.attack');
                // 置换 物品
                container.setItem(index, getItem);
                break
            };
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 幻影驱散
 */
export function PhantomDispelDustTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            // 播放 基础使用音效
            player.playSound('fire.ignite');
            /**
             * * 获取 实体 的 距离信息
             */
            const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
            /**
             * * 实体过滤器
             */
            const Filter = (entity: server.Entity) => {
                if (!entity.getComponent('minecraft:health')) return false;
                if (native_tools.PlayerInPower(player)) return true
                if (entity.target?.id !== player.id) return false;
                return true;
            };
            /**
             * * 扫描敌对生物队列
             */
            const entitys = native_tools.EntitysSort(player.dimension, { families: ['monster'] }, Distance, Filter);
            // 判断 是否扫描到敌对实体
            if (entitys.length < 1) return;
            // 遍历敌对生物队列
            entitys.forEach(
                entity => {
                    // 播放 水花 粒子效果
                    achieve_plan.SprayParticleTrigger.BriefCreate('敌对实体被清除时的水花特效', entity.location, entity.dimension);
                    // 播放 烟雾 粒子效果
                    native_tools.TrySpawnParticle(entity.dimension, 'minecraft:knockback_roar_particle', entity.getHeadLocation());
                    native_tools.TrySpawnParticle(entity.dimension, 'constant:impact_rune_white', entity.getHeadLocation());
                    native_tools.TrySpawnParticle(entity.dimension, 'constant:excite_rune_white', entity.getHeadLocation());
                    native_tools.TrySpawnParticle(entity.dimension, 'constant:pulse_rune_white', entity.getHeadLocation());
                    // 删除 实体
                    entity.remove();
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 删除 物品
            native_tools.DeleteItemStack(container, new server.ItemStack(item.typeId));
            // 播放 实体销毁时的音效
            player.playSound('cauldron.fillpotion');
            // 给与玩家 隐身效果
            player.addEffect('invisibility', 60);
        }
    }
};
/**
 * * 换装礼盒
 */
export function ClothingContainerTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 获取 神恩领航者 - 琉璃
             */
            const crystal = player.getEntitiesFromViewDirection().map(raycast => raycast.entity).filter(entity => entity.typeId == 'entity_adrift:crystal')[0]
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "§9《§5 换装礼盒 §9》§r"
            };
            /** 
             * * 定义了 窗口界面 的 选项
             */
            const option: server.RawMessage[] = [
                { text: '<§q§o§l 自然 §r>' },
                { text: '<§p§o§l 灿烂 §r>' },
                { text: '<§d§o§l 樱华 §r>' },
                { text: '<§u§o§l 梦幻 §r>' },
                { text: '<§s§o§l 漫海 §r>' },
                { text: '<§a§o§l 夏鸣 §r>' },
                { text: '<§c§o§l 领航 §r>' }
            ];
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData()
                .title(title)
                .button(option[0], "textures/项目图标/永世迷航/琉璃")
                .button(option[1], "textures/项目图标/永世迷航/琉璃")
                .button(option[2], "textures/项目图标/永世迷航/琉璃")
                .button(option[3], "textures/项目图标/永世迷航/琉璃")
                .button(option[4], "textures/项目图标/永世迷航/琉璃")
                .button(option[5], "textures/项目图标/永世迷航/琉璃")
                .button(option[6], "textures/项目图标/永世迷航/琉璃")
            // 输出 表单对象
            if (crystal?.isValid()) display.show(player).then(
                option => {
                    if (option.canceled) return;
                    // 设定琉璃的皮肤纹理
                    crystal.setProperty('entity_property:facade', Number(option.selection));
                    // 播放音效
                    player.playSound('beacon.power');
                }
            );
            // 播放 基础使用音效
            player.playSound('chime.amethyst_block');
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 方块获取
 */
export function ObtainBlock(player: server.Player, container: server.Container, block?: server.Block) {
    /**
     * * 方块的物品对象
     */
    const protoItem = block?.getItemStack(1, true);
    // 给与玩家对应 的 方块物品对象
    if (!block || !protoItem) return;
    /**
     * * 方块的附加信息
     */
    const message: server.RawMessage = {
        rawtext: [
            { text: '获取到: ' },
            native_tools.BlockTranslate(block),
            { text: ' || ' },
            native_tools.ItemTranslate(protoItem),
        ]
    };
    // 在背包中添加方块物品
    container.addItem(protoItem);
    // 输出 消息
    player.sendMessage(message);
};